This invention relates generally to a computer system for processing data and in particular to a distributed computer system such as a client-server system, for processing data.
Computer systems that have distributed data processing capabilities and distributed data storage capabilities are well known. The data may be located, for example, in a single centralized data storage location, or may be distributed throughout a plurality of different storage locations that may be connected together. Some distributed computer systems may have several computers connected to a communications network where the data stored on each computer may be replicated on every other computer so that there are multiple copies of the data distributed throughout the network. The types of data structures used to store the data and the physical locations of the storage of the data vary depending on the particular data processing application. For example, a conventional text searching and retrieval system may have a central computer system that stores all of the data in a central database and a plurality of remote computers connected through modems and phone lines to the central computer. The central computer may execute a software application that permits the remote computers to search and retrieve data from the central computer.
One conventional distributed computer system that features centralized storage of some data and the distributed processing of the data is a client-server computer system. In a conventional client-server computer system, there may be a central computer and one or more remote computers that connect to the central computer. The central computer system may be referred to as a server computer and the remote computers may be referred to as client computer(s) and there may be multiple client computers attached to the server computer. The software applications being executed by the server computer and by the client computer(s) may be referred to as server software applications and client software applications, respectively.
For a data processing client-server system, the traditional server software application may be a "dumb" data repository or database, such as an SQL database, which contains a plurality of data structures, such as tables of data, that may be set up by a database configuration utility. The server software application may accept data manipulation commands, such as SQL commands, from the client computers and respond to those data manipulation commands by either storing data in the database or retrieving data from the database. The server may have some limited application logic for maintaining the integrity of the data stored on the server, but the server may be considered "dumb" because the server software application only performs data manipulation commands and does not perform any other functions, such as generating a graphical user interface or performing mathematical calculations on the data. The server typically may store data shared by each client computer (shared data) while the client computer may store data whose value may be unique to the client computer (session data).
By contrast, a conventional client software application, located on a remote client computer with less processing power and memory than the server computer, may contain most of the application logic for the data processing system. The primary components of the client software application may be a user interface and application logic. The user interface may graphically display the data to the user and update the display of the data when necessary. The application logic may store the session data, may manage communication between the client computer software application and the server, and may implement application commands, such as applying business rules to the data or ensuring that valid data is entered into the system. The communications between the client software application and the server occur as a series of discrete data manipulation commands, known as transactions, wherein the data may be retrieved or stored into the data repository. The goal of a conventional client/server computer system is to perform as much data processing as possible on the client computer, and minimize the transactions with the server so that the server may handle multiple client sessions.
A client computer may be physically connected to the server via a modem and a phone line, for example, and each client computer's logical connection to the server may be known as a client session. There may be multiple simultaneous client computer sessions with a server computer. In these conventional client-server systems, most of the session data that is unique to each client computer may be stored by the client computer and any data shared by all of the client sessions, known as shared data, may be stored in the server's database. The session data may be personal data about a person, while shared data may be a data structure containing every person's personal data. Thus, the shared data and the session data may be separated for each other. In addition, the data structures may be completely separated from the application design because the data structures are generated by, for example, an SQL database utility. The applications, on the other hand, may be accomplished by a completely separate software application, known as a tool. The application logic may process user commands on the client computer and then issue a transaction request when communication with the server is necessary so that a developer of the client/server system must differentiate between access to data local to the client computer and access to shared data on the server.
A conventional client/server computer system may also differentiate between the execution of the client software application and the transactions with the server. The software application on the client computer is executed by logically stepping through a plurality of lines of computer code. Client computer interactions with the server, however, occur only when the client computer requires a piece of shared data and issues a transaction request. To maintain the integrity of the shared and session data, when a transaction is being executed any user commands issued during the execution of the transaction with the server must either be completed or terminated so that the data is not changed arbitrarily. For a traditional client-server system, the developer of the client/server computer system must manually validate assumptions that existed prior to a transaction's execution, such as the value of certain data fields and must then create a test condition that may either proceed with or terminate the execution of a transaction based on the test. If the transaction terminates, then the developer is assured that the shared data has not changed, but must manually reset the session data. Thus, a developer must check to ensure valid data is being used.
As described above, in a conventional client/server computer system, the data repository and the client software application are separate so that there is no explicit link between the data structures located on the server and the client software application. The client software application may include calculated fields based on shared data or session data. The shared data must be manually loaded by the client software application by issuing a transaction request to the server and temporarily storing a copy of the shared data. At this point, the temporarily stored shared data will be treated as session data and accessed by the client software application. The temporary copy of the shared data, however, may be invalidated due to another client computer's interactions with the server in which the value of the shared data changes. Therefore, during any operation that would change that temporarily stored shared data, a transaction is started which revalidates the shared data with the server and generates a transaction failure if the session data is not valid. In addition, if a developer wants to refresh the data on the client computer's screen from time-to-time, the data must be revalidated against the server copy of the shared data from time to time. In addition, if multiple users are looking at the same piece of data, then this revalidation process must occur for each user, which is time consuming. Therefore, calculating values and revalidating temporary copies of shared data is a slow process, but necessary because the shared data and session data are stored separately. The traditional client/server system also does not provide a simple system to calculate a value which depends on other values.
A conventional client-server computer system also requires the developer of the client/server computer system to work in several different programming language environments that require the developer to understand and be able to write software applications in several different programming languages. For example, for a conventional client-server computer system located on the Internet, a developer must understand a database programming language, such as SQL, in order to write the database software application located on the server. The developer must also understand one or more application programming languages, such as PERL, Cobol or C, to write the software application that contains most of the application logic, resides on the server, and may download data to the client computer when the client computer requests the data. The developer must also understand a user interface programming language, such as the hypertext mark-up language (HTML) to write the software application that resides on the server, and provides the user with a graphical user interface to interact with the server computer and the database. Therefore, a developer must understand and be able to write software applications in several different programming languages to produce a single client-server application.
In summary, a traditional client-server system may have shared data and session data stored separately which requires revalidation of shared data temporarily displayed on a client computer through a transaction. The separation of the shared and session data also makes calculations using shared data and updates of those calculations more difficult because the shared data must be retrieved by transaction. In addition, the traditional server may be a "dumb" data repository so that each client computer must execute a large software application. A traditional client-server system also requires a developer of a client-server system to use several different programming languages, and the developer must separately generate the data structure and the client software application.
Thus, there is a need for a distributed data processing system and method which avoid these and other problems of known devices, and it is to this end that the present invention is directed.